package com.example.forwardmessages

import android.app.AlertDialog
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.PowerManager
import android.provider.Settings
import android.util.Log
import android.content.pm.PackageManager
import androidx.core.content.ContextCompat
import android.text.TextUtils

/**
 * MIUI系统权限辅助类，用于检测MIUI系统并引导用户开启自启动权限
 */
object MIUIPermissionHelper {
    private const val TAG = "MIUIPermissionHelper"
    
    // 必要的权限列表
    private val REQUIRED_PERMISSIONS = arrayOf(
        android.Manifest.permission.RECEIVE_BOOT_COMPLETED,
        android.Manifest.permission.WAKE_LOCK,
        android.Manifest.permission.FOREGROUND_SERVICE
    )
    
    // MIUI权限相关组件名
    private val MIUI_PERMISSION_COMPONENTS = arrayOf(
        "com.miui.securitycenter/com.miui.permcenter.autostart.AutoStartManagementActivity",
        "com.miui.securitycenter/com.miui.permcenter.autostart.SmartAutoStartManagementActivity",
        "com.miui.securitycenter/com.miui.powercenter.PowerSettings",
        "com.miui.securitycenter/com.miui.permcenter.PermissionManagerActivity",
        "com.miui.securitycenter/com.miui.appmanager.ApplicationsStateActivity",
        "com.miui.securitycenter/com.miui.appmanager.AppManager",
        "com.miui.securitycenter/com.miui.appmanager.AppManager\$AppMemoryUsageActivity",
        "com.miui.securitycenter/com.miui.permcenter.permissions.PermissionsEditorActivity",
        "com.miui.powerkeeper/com.miui.powerkeeper.ui.HiddenAppsContainerManagementActivity",
        "com.miui.securitycenter/com.miui.permcenter.autostart.AutoStartManagementActivity"
    )
    
    /**
     * 检查是否为MIUI系统
     */
    fun isMIUI(): Boolean {
        return try {
            val property = getSystemProperty("ro.miui.ui.version.name")
            val isMIUIBuild = getSystemProperty("ro.miui.build.display.id") != null
            val isMIUIModel = getSystemProperty("ro.product.mod_device")?.contains("miui") ?: false
            
            Log.d(TAG, "MIUI版本: $property, 是MIUI构建: $isMIUIBuild, 是MIUI模型: $isMIUIModel")
            
            (property != null && property.isNotEmpty()) || isMIUIBuild || isMIUIModel
        } catch (e: Exception) {
            Log.e(TAG, "检测MIUI系统失败: ${e.message}")
            false
        }
    }
    
    /**
     * 获取MIUI版本
     */
    fun getMIUIVersion(): String {
        return try {
            getSystemProperty("ro.miui.ui.version.name") ?: "未知"
        } catch (e: Exception) {
            "未知"
        }
    }
    
    /**
     * 检查自启动权限是否已开启
     */
    fun checkAutoStartPermission(context: Context): Boolean {
        if (!isMIUI()) {
            // 非MIUI系统默认返回true
            Log.d(TAG, "非MIUI系统，跳过自启动权限检查")
            return true
        }
        
        try {
            // 尝试检查电池优化白名单
            val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
            val packageName = context.packageName
            val isIgnoringBatteryOptimizations = powerManager.isIgnoringBatteryOptimizations(packageName)
            
            Log.d(TAG, "电池优化白名单状态: $isIgnoringBatteryOptimizations")
            return isIgnoringBatteryOptimizations
        } catch (e: Exception) {
            Log.e(TAG, "检查自启动权限失败: ${e.message}")
            return false
        }
    }
    
    /**
     * 检查是否已经授予所有必要的权限
     */
    fun checkAllRequiredPermissions(context: Context): Boolean {
        if (!isMIUI()) {
            return true
        }
        
        // 检查电池优化白名单
        if (!checkAutoStartPermission(context)) {
            return false
        }
        
        // 检查运行时权限
        for (permission in REQUIRED_PERMISSIONS) {
            if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                Log.d(TAG, "缺少必要权限: $permission")
                return false
            }
        }
        
        // 检查应用是否在后台运行白名单中
        val isBackgroundRestricted = checkBackgroundRestriction(context)
        if (isBackgroundRestricted) {
            return false
        }
        
        return true
    }
    
    /**
     * 检查应用是否被MIUI限制在后台运行
     */
    private fun checkBackgroundRestriction(context: Context): Boolean {
        return try {
            // 尝试通过反射检查后台限制
            val appOps = context.getSystemService("appops")
            val appOpsClass = Class.forName("android.app.AppOpsManager")
            val checkOpMethod = appOpsClass.getMethod("checkOpNoThrow", Integer.TYPE, Integer.TYPE, String::class.java)
            val getUidForNameMethod = Class.forName("android.os.Process").getMethod("myUid")
            val uid = getUidForNameMethod.invoke(null) as Int
            
            // 检查后台限制操作
            val opBackgroundCheck = 28 // AppOpsManager.OP_RUN_ANY_IN_BACKGROUND
            val result = checkOpMethod.invoke(appOps, opBackgroundCheck, uid, context.packageName) as Int
            
            val isRestricted = result != 0
            Log.d(TAG, "后台运行限制检查结果: $isRestricted")
            isRestricted
        } catch (e: Exception) {
            Log.e(TAG, "检查后台限制失败: ${e.message}")
            false
        }
    }
    
    /**
     * 请求所有必要的MIUI权限和设置，以支持激进的后台保活策略
     */
    fun requestAllRequiredPermissionsForAggressiveKeepAlive(context: Context) {
        if (!isMIUI()) {
            Log.d(TAG, "非MIUI系统，不需要特殊权限设置")
            return
        }
        
        // 先检查电池优化白名单
        if (!checkAutoStartPermission(context)) {
            showAggressiveBatteryOptimizationDialog(context)
        } else {
            // 如果电池优化已开启，再检查自启动权限
            showAggressiveAutoStartPermissionDialog(context)
        }
    }
    
    /**
     * 引导用户开启MIUI自启动权限和相关设置
     */
    fun requestAllRequiredPermissions(context: Context) {
        if (!isMIUI()) {
            Log.d(TAG, "非MIUI系统，不需要特殊权限设置")
            return
        }
        
        // 先检查电池优化白名单
        if (!checkAutoStartPermission(context)) {
            showBatteryOptimizationDialog(context)
        } else {
            // 如果电池优化已开启，再检查自启动权限
            showAutoStartPermissionDialog(context)
        }
    }
    
    /**
     * 引导用户开启MIUI自启动权限
     */
    fun showAutoStartPermissionDialog(context: Context) {
        if (!isMIUI()) {
            return
        }
        
        try {
            val miuiVersion = getMIUIVersion()
            val message = when {
                miuiVersion.contains("12") || miuiVersion.contains("13") || miuiVersion.contains("14") -> 
                    "为了确保应用在开机后能正常启动，请在MIUI设置中完成以下操作：\n\n" +
                    "1. 允许自启动：设置 → 应用设置 → 应用管理 → 找到本应用 → 权限管理 → 自启动管理 → 允许自启动\n" +
                    "2. 后台运行权限：设置 → 应用设置 → 应用管理 → 找到本应用 → 省电策略 → 选择'无限制'\n" +
                    "3. 锁定应用：从最近任务列表中长按应用图标 → 选择'锁定'"
                else -> 
                    "为了确保应用在开机后能正常启动，请在MIUI设置中允许应用自启动。\n\n" +
                    "步骤：设置 → 应用管理 → 权限管理 → 自启动管理 → 找到并允许本应用"
            }
            
            // 显示对话框提示用户开启自启动权限
            AlertDialog.Builder(context)
                .setTitle("MIUI自启动设置")
                .setMessage(message)
                .setPositiveButton("去设置") { _, _ ->
                    // 跳转到MIUI自启动管理页面
                    navigateToAutoStartSettings(context)
                }
                .setNegativeButton("取消", null)
                .show()
        } catch (e: Exception) {
            Log.e(TAG, "显示权限请求对话框失败: ${e.message}")
        }
    }
    
    /**
     * 激进模式下的自启动权限对话框，提供更详细的设置说明
     */
    fun showAggressiveAutoStartPermissionDialog(context: Context) {
        if (!isMIUI()) {
            return
        }
        
        try {
            val miuiVersion = getMIUIVersion()
            val message = when {
                miuiVersion.contains("12") || miuiVersion.contains("13") || miuiVersion.contains("14") -> 
                    "【重要设置】为确保应用能在后台稳定运行，必须完成以下所有设置：\n\n" +
                    "1. 自启动管理：设置 → 应用设置 → 应用管理 → 找到本应用 → 权限管理 → 自启动管理 → 允许自启动\n" +
                    "2. 省电策略：设置 → 应用设置 → 应用管理 → 找到本应用 → 省电策略 → 选择'无限制'\n" +
                    "3. 后台弹出界面：设置 → 应用设置 → 应用管理 → 找到本应用 → 权限管理 → 后台弹出界面 → 允许\n" +
                    "4. 锁定应用：从最近任务列表中长按应用图标 → 选择'锁定'\n" +
                    "5. 多任务界面：最近任务界面下滑应用卡片加锁\n" +
                    "6. 省电优化：设置 → 省电与电池 → 电池 → 选择'性能模式'"
                else -> 
                    "【重要设置】以确保应用能在后台稳定运行，必须完成以下设置：\n\n" +
                    "1. 自启动管理：设置 → 应用管理 → 权限管理 → 自启动管理 → 允许本应用\n" +
                    "2. 省电策略：设置 → 电量和性能 → 应用省电 → 选择'无限制'\n" +
                    "3. 锁定应用：从最近任务列表中长按应用图标 → 选择'锁定'"
            }
            
            // 显示对话框提示用户开启自启动权限
            AlertDialog.Builder(context)
                .setTitle("MIUI后台保活设置（重要）")
                .setMessage(message)
                .setPositiveButton("去设置") { _, _ ->
                    // 跳转到MIUI自启动管理页面
                    navigateToAggressiveAutoStartSettings(context)
                }
                .setNegativeButton("稍后", null)
                .show()
        } catch (e: Exception) {
            Log.e(TAG, "显示激进模式权限请求对话框失败: ${e.message}")
        }
    }
    
    /**
     * 显示请求忽略电池优化的对话框
     */
    fun showBatteryOptimizationDialog(context: Context) {
        if (!isMIUI()) {
            return
        }
        
        try {
            // 显示对话框提示用户忽略电池优化
            AlertDialog.Builder(context)
                .setTitle("电池优化设置")
                .setMessage("为了确保应用在开机后能正常启动，请将应用添加到电池优化白名单。\n\n" +
                        "这将允许应用在后台保持运行，不受MIUI省电策略的限制。")
                .setPositiveButton("去设置") { _, _ ->
                    requestIgnoreBatteryOptimizations(context)
                }
                .setNegativeButton("稍后", null)
                .show()
        } catch (e: Exception) {
            Log.e(TAG, "显示电池优化对话框失败: ${e.message}")
        }
    }
    
    /**
     * 激进模式下的电池优化对话框，强调重要性
     */
    fun showAggressiveBatteryOptimizationDialog(context: Context) {
        if (!isMIUI()) {
            return
        }
        
        try {
            // 显示对话框提示用户忽略电池优化
            AlertDialog.Builder(context)
                .setTitle("【关键】电池优化设置")
                .setMessage("为了确保应用能在后台持续稳定运行，必须将应用添加到电池优化白名单！\n\n" +
                        "这是MIUI系统中最重要的设置，决定了应用能否在后台存活。\n\n" +
                        "设置后，应用将不受MIUI省电策略限制，保证消息能够及时处理和转发。")
                .setPositiveButton("立即设置") { _, _ ->
                    requestIgnoreBatteryOptimizations(context)
                }
                .setNegativeButton("暂不设置") { _, _ ->
                    // 再次提示用户设置的重要性
                    AlertDialog.Builder(context)
                        .setTitle("重要提醒")
                        .setMessage("不完成电池优化设置，应用在后台可能会被MIUI系统强制关闭，导致功能失效。建议立即完成设置。")
                        .setPositiveButton("去设置") { _, _ ->
                            requestIgnoreBatteryOptimizations(context)
                        }
                        .setNegativeButton("我知道了", null)
                        .show()
                }
                .show()
        } catch (e: Exception) {
            Log.e(TAG, "显示激进模式电池优化对话框失败: ${e.message}")
        }
    }
    
    /**
     * 请求忽略电池优化
     */
    fun requestIgnoreBatteryOptimizations(context: Context) {
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
                intent.data = Uri.parse("package:" + context.packageName)
                context.startActivity(intent)
                Log.d(TAG, "已跳转到电池优化设置页面")
            }
        } catch (e: Exception) {
            Log.e(TAG, "跳转到电池优化设置页面失败: ${e.message}")
            // 如果失败，尝试跳转到应用详情页
            try {
                val appDetailIntent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                appDetailIntent.data = Uri.fromParts("package", context.packageName, null)
                context.startActivity(appDetailIntent)
            } catch (e2: Exception) {
                Log.e(TAG, "跳转到应用详情页也失败: ${e2.message}")
            }
        }
    }
    
    /**
     * 跳转到MIUI自启动管理页面
     */
    fun navigateToAutoStartSettings(context: Context) {
        navigateToMIUSettings(context, MIUI_PERMISSION_COMPONENTS)
    }
    
    /**
     * 跳转到激进模式的MIUI设置页面，尝试更多可能的设置路径
     */
    fun navigateToAggressiveAutoStartSettings(context: Context) {
        // 尝试更多可能的MIUI设置路径，包括省电、后台限制等
        val aggressiveComponents = arrayOf(
            // 自启动管理
            "com.miui.securitycenter/com.miui.permcenter.autostart.AutoStartManagementActivity",
            // 后台弹出界面
            "com.miui.securitycenter/com.miui.permcenter.permissions.PermissionsEditorActivity",
            // 省电策略
            "com.miui.powerkeeper/com.miui.powerkeeper.ui.HiddenAppsContainerManagementActivity",
            // 电池设置
            "com.miui.securitycenter/com.miui.powercenter.PowerSettings",
            // 权限管理
            "com.miui.securitycenter/com.miui.permcenter.PermissionManagerActivity",
            // 应用管理
            "com.miui.securitycenter/com.miui.appmanager.ApplicationsStateActivity"
        )
        
        navigateToMIUSettings(context, aggressiveComponents)
    }
    
    /**
     * 尝试跳转到指定的MIUI设置组件
     */
    private fun navigateToMIUSettings(context: Context, componentNames: Array<String>) {
        val intent = Intent()
        intent.action = "miui.intent.action.OP_AUTO_START"
        intent.addCategory(Intent.CATEGORY_DEFAULT)
        
        var found = false
        for (componentName in componentNames) {
            try {
                val parts = componentName.split("/").toTypedArray()
                if (parts.size == 2) {
                    intent.setClassName(parts[0], parts[1])
                    context.startActivity(intent)
                    found = true
                    Log.d(TAG, "成功跳转到设置页面: $componentName")
                    break
                }
            } catch (e: Exception) {
                // 尝试下一个路径
                Log.d(TAG, "无法跳转到页面: $componentName, 错误: ${e.message}")
            }
        }
        
        // 如果找不到MIUI特定页面，则跳转到应用详情页
        if (!found) {
            Log.d(TAG, "未找到MIUI特定设置页面，跳转到应用详情页")
            val appDetailIntent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
            appDetailIntent.data = Uri.fromParts("package", context.packageName, null)
            context.startActivity(appDetailIntent)
        }
    }
    
    /**
     * 获取系统属性
     */
    private fun getSystemProperty(key: String): String? {
        return try {
            val clazz = Class.forName("android.os.SystemProperties")
            val method = clazz.getMethod("get", String::class.java)
            method.invoke(null, key) as String?
        } catch (e: Exception) {
            Log.e(TAG, "获取系统属性失败: $key, 错误: ${e.message}")
            null
        }
    }
}